use std::{io, thread, time};
use std::io::{BufRead, BufReader, Read, Write};
use std::net::{TcpListener, TcpStream};
use std::str::from_utf8;

fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:7788")?;

    // 设置套接字的生存时间（TTL）。
    listener.set_ttl(100).expect("could not set TTL");

    // 返回此侦听器的本地套接字地址。
    let _addr = listener.local_addr()?;

    // 获取此套接字上 SO_ERROR 选项的值。
    listener.take_error().expect("No error was expected");

    //将此 TCP 流移入或移出非阻塞模式。
    // listener.set_nonblocking(true).expect("could not set non-blocking");

    // 获取套接字的生存时间（TTL）。
    let _ttlValue = listener.ttl().unwrap_or(0);

    // 为底层套接字创建一个新的独立的拥有所有权的句柄。
    let _listener_clone = listener.try_clone().unwrap();

    // 接受此侦听器上的连接。
    match listener.accept() {
        Ok((_socket, addr)) => println!("new client: {addr:?}"),
        Err(e) => println!("couldn't get client: {e:?}"),
    }

    // 在此侦听器上接收到的连接上将其转换为迭代器。
    // let _ = listener.into_incoming().filter_map(Result::ok); /* Ignore failed connections */

    // 返回在此侦听器上接收到的连接上的迭代器。
    for stream in listener.incoming() {
        match stream {
            Ok(mut stream) => {
                println!("new client: {stream:?}");
                // 用 TcpStream 做某事
                handle_connection(stream);
                // let msg = stream.read(&mut [0; 1024]).expect("read error");
                // println!("msg: {msg}");
            }
            Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => {
                // 等待网络套接字就绪，通常通过平台特定的 API (例如 epoll 或 IOCP) 实现
                // wait_for_fd();
                continue;
            }
            Err(e) => {
                println!("couldn't get client: {e:?}");
            }
        }
    }

    Ok(())
}

fn handle_connection(mut stream: TcpStream) -> io::Result<()> {
    // let mut buf = [0; 512];

    let mut reader = BufReader::new(&stream);
    let mut buffer: Vec<u8> = Vec::new();
    reader.read_until(b'\n', &mut buffer).expect("Failed to read into buffer");
    // let msg = stream.read(&mut buf).expect("read error");
    // println!("msg: {msg}");
    println!("buf: {:?}", from_utf8(&buffer));
    println!("read  from server: {}",from_utf8(&buffer).unwrap());
    // todo!()
    stream.write(&[1, 2, 3]).expect("write error");
    thread::sleep(time::Duration::from_secs(1));
    Ok(())
}
